package com.li.streamAPI;

import com.li.java2.Employee;
import com.li.java2.EmployeeData;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * @author 喂S别闹
 * @create 2022/4/21-9:45
 * @Version 1.0
 * @Description: StreamAPI的测试
 * <p>
 * Stream关注的是对数据的运算，与CPU交道，
 * <p>
 * Stream自己不会存储元素
 * Steam不会改变源对象。相反，他们会返回一个持有结果的新Stream
 * Steam操作是延迟执行，这意味着他们会等到需要结果的时候才执行
 * <p>
 * Stream操作步骤
 * 实例化-》中间操作-》终止操作 （终止之后就不能在使用了）
 */
public class StreamAPITest {

    /**
     * @Date: 2022/4/21 9:51
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:创建Stream：通过集合创建
     */
    @Test
    public void test1() {
        List<Employee> employees = EmployeeData.getEmployees();
//        default Stream<E> stream() 返回一个顺序流
        Stream<Employee> stream = employees.stream();
//         default Stream<E> parallelStream()返回一个并行流
        Stream<Employee> employeeStream = employees.parallelStream();

    }

    /**
     * @Date: 2022/4/21 9:55
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:通过数组获取Stream流
     */
    @Test
    public void test2() {
        int[] arr = {1, 2, 3, 4, 5, 6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array)：返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001, "123");
        Employee e2 = new Employee(1002, "2222");
        Employee[] employees = {e1, e2};
        Stream<Employee> stream1 = Arrays.stream(employees);

    }

    /**
     * @Date: 2022/4/21 9:58
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:通过Stream的of()
     */
    @Test
    public void test3() {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
    }

    /**
     * @Date: 2022/4/21 9:59
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:创建无限流
     */
    @Test
    public void test4() {
        //迭代
        //public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);

        //生成
        //public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

}
